{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:23:25.034743Z",
     "start_time": "2025-03-06T14:23:25.026765Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=9, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.1\n",
      "numpy 2.0.1\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:13.112580Z",
     "start_time": "2025-03-06T14:41:13.060828Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到`dataloader`\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:23.321245Z",
     "start_time": "2025-03-06T14:41:13.505235Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds: # 遍历每张图片,img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205]) # 这里的均值和标准差是通过train_ds计算得到的\n",
    ")\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:27.942567Z",
     "start_time": "2025-03-06T14:41:27.927230Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        # 加19层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        # print('''初始化权重''')\n",
    "        for m in self.modules():\n",
    "            # print(m)\n",
    "            # print('-'*50)\n",
    "            if isinstance(m, nn.Linear):#判断m是否为全连接层\n",
    "                # https://pytorch.org/docs/stable/nn.init.html\n",
    "                nn.init.xavier_uniform_(m.weight) # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias) # 全零初始化偏置项\n",
    "        # print('''初始化权重完成''')\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x) #标准化\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "total=0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\") #np.prod是计算张量的元素个数\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total+=np.prod(value.shape)\n",
    "total #模型参数数量"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.int64(271410)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "source": [
    "w = torch.empty(3, 5)\n",
    "print(w)\n",
    "nn.init.eye_(w)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:28.521620Z",
     "start_time": "2025-03-06T14:41:28.513836Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-2.5121e-27,  1.3004e-42,  0.0000e+00,  0.0000e+00,  0.0000e+00],\n",
      "        [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00],\n",
      "        [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[1., 0., 0., 0., 0.],\n",
       "        [0., 1., 0., 0., 0.],\n",
       "        [0., 0., 1., 0., 0.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:29.411994Z",
     "start_time": "2025-03-06T14:41:29.348021Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:34.003219Z",
     "start_time": "2025-03-06T14:41:29.794900Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:34.011133Z",
     "start_time": "2025-03-06T14:41:34.004211Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:34.016991Z",
     "start_time": "2025-03-06T14:41:34.012128Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:34.593658Z",
     "start_time": "2025-03-06T14:41:34.581690Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n"
   ],
   "outputs": [],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "source": [
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n",
    "model = model.to(device)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T14:41:36.403762Z",
     "start_time": "2025-03-06T14:41:36.113783Z"
    }
   },
   "outputs": [],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "source": [
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-06T15:00:55.999872Z",
     "start_time": "2025-03-06T14:41:39.293262Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "c01a978096c54a2fac56de79624c5f31"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 33 / global_step 123750\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T15:15:39.385056Z",
     "start_time": "2025-03-06T15:15:39.032344Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T02:23:36.828927Z",
     "start_time": "2025-01-17T02:23:35.958773Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.4257\n",
      "accuracy: 0.8834\n"
     ]
    }
   ],
   "execution_count": 48
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
